JavaScript Asinxron Generatorlarida Resurslarni Boshqarish: Barqaror Ilovalar Uchun Oqimlarni Tozalash

JavaScript'dagi asinxron generatorlar (async generators) asinxron ma'lumotlar oqimlarini boshqarish uchun kuchli mexanizmni taqdim etadi. Biroq, ushbu generatorlar ichida resurslarni, xususan, oqimlarni to'g'ri boshqarish xotira sizib chiqishining oldini olish va ilovalaringiz barqarorligini ta'minlash uchun juda muhimdir. Ushbu batafsil qo'llanma JavaScript asinxron generatorlarida resurslarni boshqarish va oqimlarni tozalash bo'yicha eng yaxshi amaliyotlarni o'rganadi, amaliy misollar va foydali maslahatlar taklif etadi.

Asinxron Generatorlarni Tushunish

Asinxron generatorlar — bu pauza qilinishi va qayta ishga tushirilishi mumkin bo'lgan funksiyalar bo'lib, ular qiymatlarni asinxron tarzda qaytarishga (yield) imkon beradi. Bu ularni katta hajmdagi ma'lumotlar to'plamlarini qayta ishlash, API'lardan ma'lumotlarni oqim shaklida olish va real vaqtdagi hodisalarni boshqarish uchun ideal qiladi.

Asinxron generatorlarning asosiy xususiyatlari:

• Asinxronlik: Ular async kalit so'zidan foydalanadi va Promise'larni await qila oladi.
• Iteratorlar: Ular iterator protokolini amalga oshiradi, bu esa ularni for await...of sikllari yordamida ishlatishga imkon beradi.
• Qiymat qaytarish: Ular qiymatlarni hosil qilish uchun yield kalit so'zidan foydalanadi.

Oddiy asinxron generator misoli:

            async function* generateNumbers(count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Asinxron operatsiyani simulyatsiya qilish
    yield i;
  }
}

(async () => {
  for await (const number of generateNumbers(5)) {
    console.log(number);
  }
})();

            

              
                Copy
              
            
          

Resurslarni Boshqarishning Muhimligi

Asinxron generatorlar bilan ishlaganda, ayniqsa oqimlar bilan ishlaydiganlarda (masalan, fayldan o'qish, tarmoqdan ma'lumotlarni olish), resurslarni samarali boshqarish juda muhim. Buni qilmaslik quyidagilarga olib kelishi mumkin:

• Xotira Sizib Chiqishi: Agar oqimlar to'g'ri yopilmasa, ular resurslarni ushlab turishi mumkin, bu esa xotira sarfini oshiradi va ilovaning ishdan chiqishiga olib kelishi mumkin.
• Fayl Dastaklari Tugashi: Agar fayl oqimlari yopilmasa, operatsion tizimda mavjud fayl dastaklari tugab qolishi mumkin.
• Tarmoq Ulanishidagi Muammolar: Yopilmagan tarmoq ulanishlari server tomonida resurslarning tugashiga va klient tomonida ulanish chegaralariga olib kelishi mumkin.
• Kutilmagan Xatti-harakatlar: To'liq bo'lmagan yoki uzilgan oqimlar ilovaning kutilmagan xatti-harakatlariga va ma'lumotlarning buzilishiga olib kelishi mumkin.

Resurslarni to'g'ri boshqarish oqimlar endi kerak bo'lmaganda ularning to'g'ri yopilishini ta'minlaydi, resurslarni bo'shatadi va ushbu muammolarning oldini oladi.

Oqim Resurslarini Tozalash Texnikalari

JavaScript asinxron generatorlarida oqimning to'g'ri tozalanishini ta'minlash uchun bir nechta usullardan foydalanish mumkin:

1. try...finally Bloki

try...finally bloki — bu xatolik yuz berishidan yoki generatorning normal yakunlanishidan qat'i nazar, tozalash kodining har doim bajarilishini ta'minlaydigan asosiy mexanizm.

Tuzilishi:

            async function* processStream(stream) {
  try {
    // Oqimni qayta ishlash
    while (true) {
      const chunk = await stream.read();
      if (!chunk) break;
      yield processChunk(chunk);
    }
  } finally {
    // Tozalash kodi: Oqimni yopish
    if (stream) {
      await stream.close();
      console.log('Oqim yopildi.');
    }
  }
}

            

              
                Copy
              
            
          

Tushuntirish:

• try bloki oqimni qayta ishlaydigan kodni o'z ichiga oladi.
• finally bloki tozalash kodini o'z ichiga oladi, u try bloki muvaffaqiyatli yakunlanadimi yoki xatolik yuz beradimi, qat'i nazar, bajariladi.
• stream.close() metodi oqimni yopish va resurslarni bo'shatish uchun chaqiriladi. U generator'dan chiqishdan oldin yakunlanishini ta'minlash uchun `awaited` qilinadi.

Node.js fayl oqimi bilan misol:

            const fs = require('fs');
const { Readable } = require('stream');

async function* processFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    for await (const chunk of fileStream) {
      yield chunk.toString();
    }
  } finally {
    if (fileStream) {
      fileStream.close(); // fs tomonidan yaratilgan oqimlar uchun close dan foydalaning
      console.log('Fayl oqimi yopildi.');
    }
  }
}

(async () => {
  const filePath = 'example.txt'; // O'zingizning fayl yo'lingiz bilan almashtiring
  fs.writeFileSync(filePath, 'Bu bir nechta qatorli misol kontenti.\nOqimni qayta ishlashni namoyish qilish uchun.');

  for await (const line of processFile(filePath)) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

Muhim E'tiborlar:

• Oqim hech qachon ishga tushirilmagan bo'lsa, xatoliklarning oldini olish uchun uni yopishga urinishdan oldin oqim mavjudligini tekshiring.
• Generator'dan chiqishdan oldin oqimning to'liq yopilishini kafolatlash uchun close() metodining kutilganligiga (awaited) ishonch hosil qiling. Ko'pgina oqim implementatsiyalari asinxrondir.

2. Resurs Ajratish va Tozalash uchun O'rovchi Funksiyadan Foydalanish

Yana bir yondashuv — resurs ajratish va tozalash mantig'ini o'rovchi (wrapper) funksiya ichiga joylashtirish. Bu kodning qayta ishlatilishini rag'batlantiradi va generator kodini soddalashtiradi.

            async function withResource(resourceFactory, generatorFunction) {
  let resource;
  try {
    resource = await resourceFactory();
    for await (const value of generatorFunction(resource)) {
      yield value;
    }
  } finally {
    if (resource) {
      await resource.cleanup();
      console.log('Resurs tozalandi.');
    }
  }
}

            

              
                Copy
              
            
          

Tushuntirish:

• resourceFactory: Resursni yaratadigan va qaytaradigan funksiya (masalan, oqim).
• generatorFunction: Resursdan foydalanadigan asinxron generator funksiyasi.
• withResource funksiyasi resursning hayot siklini boshqaradi, uning yaratilishini, generator tomonidan ishlatilishini va keyin finally blokida tozalanishini ta'minlaydi.

Maxsus oqim sinfi yordamida misol:

            class CustomStream {
  constructor() {
    this.data = ['1-qator', '2-qator', '3-qator'];
    this.index = 0;
  }

  async read() {
    await new Promise(resolve => setTimeout(resolve, 50)); // Asinxron o'qishni simulyatsiya qilish
    if (this.index < this.data.length) {
      return this.data[this.index++];
    } else {
      return null;
    }
  }

  async cleanup() {
    console.log('CustomStream tozalash tugallandi.');
  }
}

async function* processCustomStream(stream) {
  while (true) {
    const chunk = await stream.read();
    if (!chunk) break;
    yield `Qayta ishlandi: ${chunk}`;
  }
}

async function withResource(resourceFactory, generatorFunction) {
  let resource;
  try {
    resource = await resourceFactory();
    for await (const value of generatorFunction(resource)) {
      yield value;
    }
  } finally {
    if (resource && resource.cleanup) {
      await resource.cleanup();
      console.log('Resurs tozalandi.');
    }
  }
}


(async () => {
  for await (const line of withResource(() => new CustomStream(), processCustomStream)) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

3. AbortController dan foydalanish

AbortController — bu asinxron operatsiyalarni, shu jumladan oqimni qayta ishlashni bekor qilish signalini berishga imkon beruvchi o'rnatilgan JavaScript API. Bu, ayniqsa, taymautlar, foydalanuvchi bekor qilishlari yoki oqimni muddatidan oldin to'xtatish kerak bo'lgan boshqa vaziyatlarni boshqarish uchun foydalidir.

            async function* processStreamWithAbort(stream, signal) {
  try {
    while (!signal.aborted) {
      const chunk = await stream.read();
      if (!chunk) break;
      yield processChunk(chunk);
    }
  } finally {
    if (stream) {
      await stream.close();
      console.log('Oqim yopildi.');
    }
  }
}

(async () => {
  const controller = new AbortController();
  const { signal } = controller;

  // Taymautni simulyatsiya qilish
  setTimeout(() => {
    console.log('Oqimni qayta ishlash bekor qilinmoqda...');
    controller.abort();
  }, 2000);

  const stream = createSomeStream(); // O'zingizning oqim yaratish mantig'ingiz bilan almashtiring

  try {
    for await (const chunk of processStreamWithAbort(stream, signal)) {
      console.log('Chunk:', chunk);
    }
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Oqimni qayta ishlash bekor qilindi.');
    } else {
      console.error('Oqimni qayta ishlashda xatolik:', error);
    }
  }
})();

            

              
                Copy
              
            
          

Tushuntirish:

• AbortController yaratiladi va uning signali generator funksiyasiga uzatiladi.
• Generator har bir iteratsiyada operatsiya bekor qilinganligini aniqlash uchun signal.aborted xususiyatini tekshiradi.
• Agar signal bekor qilinsa, sikl to'xtaydi va oqimni yopish uchun finally bloki bajariladi.
• Operatsiyani bekor qilish signalini berish uchun controller.abort() metodi chaqiriladi.

AbortController dan foydalanishning afzalliklari:

• Asinxron operatsiyalarni bekor qilishning standart usulini taqdim etadi.
• Oqimni qayta ishlashni toza va oldindan aytib bo'ladigan tarzda bekor qilishga imkon beradi.
• AbortSignal ni qo'llab-quvvatlaydigan boshqa asinxron API'lar bilan yaxshi integratsiyalashadi.

4. Oqimni Qayta Ishlash Paytidagi Xatoliklarni Boshqarish

Oqimni qayta ishlash paytida xatoliklar yuz berishi mumkin, masalan, tarmoq xatolari, faylga kirish xatolari yoki ma'lumotlarni tahlil qilish xatolari. Generatorning ishdan chiqishini oldini olish va resurslarning to'g'ri tozalanishini ta'minlash uchun ushbu xatoliklarni to'g'ri boshqarish juda muhimdir.

            async function* processStreamWithErrorHandling(stream) {
  try {
    while (true) {
      try {
        const chunk = await stream.read();
        if (!chunk) break;
        yield processChunk(chunk);
      } catch (error) {
        console.error('Chunkni qayta ishlashda xatolik:', error);
        // Ixtiyoriy ravishda xatoni qayta yuborishni yoki qayta ishlashni davom ettirishni tanlashingiz mumkin
        // throw error;
      }
    }
  } finally {
    if (stream) {
      try {
        await stream.close();
        console.log('Oqim yopildi.');
      } catch (closeError) {
        console.error('Oqimni yopishda xatolik:', closeError);
      }
    }
  }
}

            

              
                Copy
              
            
          

Tushuntirish:

• Alohida chunklarni o'qish va qayta ishlash paytida yuzaga keladigan xatoliklarni boshqarish uchun ichki try...catch bloki ishlatiladi.
• catch bloki xatoni qayd etadi va ixtiyoriy ravishda xatoni qayta yuborish yoki qayta ishlashni davom ettirish imkonini beradi.
• finally bloki oqimni yopish paytida yuzaga kelishi mumkin bo'lgan xatoliklarni boshqarish uchun try...catch blokini o'z ichiga oladi. Bu yopish paytidagi xatolar generatorning chiqishiga to'sqinlik qilmasligini ta'minlaydi.

5. Oqimlarni Boshqarish uchun Kutubxonalardan Foydalanish

Bir nechta JavaScript kutubxonalari oqimlarni boshqarish va resurslarni tozalashni soddalashtirish uchun yordamchi dasturlarni taqdim etadi. Ushbu kutubxonalar andoza kodini kamaytirishga va ilovalaringiz ishonchliligini oshirishga yordam beradi.

Misollar:

• `node-cleanup` (Node.js): Ushbu kutubxona jarayon tugaganda bajariladigan tozalash ishlovchilarini ro'yxatdan o'tkazishning oddiy usulini taqdim etadi.
• `rxjs` (JavaScript uchun Reaktiv Kengaytmalar): RxJS asinxron ma'lumotlar oqimlarini boshqarish uchun kuchli abstraksiyani taqdim etadi va resurslarni boshqarish hamda xatoliklarni qayta ishlash uchun operatorlarni o'z ichiga oladi.
• ` Highland.js` (Highland): Highland — bu oqimlar bilan murakkabroq ishlarni bajarishingiz kerak bo'lsa foydali bo'lgan oqim kutubxonasi.

`node-cleanup` dan foydalanish (Node.js):

            const fs = require('fs');
const cleanup = require('node-cleanup');

async function* processFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    for await (const chunk of fileStream) {
      yield chunk.toString();
    }
  } finally {
    // Bu har doim ham ishlamasligi mumkin, chunki jarayon kutilmaganda to'xtatilishi mumkin.
    // Generatorning o'zida try...finally dan foydalanish afzalroq.
  }
}


(async () => {
  const filePath = 'example.txt'; // O'zingizning fayl yo'lingiz bilan almashtiring
  fs.writeFileSync(filePath, 'Bu bir nechta qatorli misol kontenti.\nOqimni qayta ishlashni namoyish qilish uchun.');

  const stream = processFile(filePath);
  let fileStream = fs.createReadStream(filePath);

  cleanup(function (exitCode, signal) {
        // fayllarni tozalash, ma'lumotlar bazasidagi yozuvlarni o'chirish va hokazo
    fileStream.close();
    console.log('Fayl oqimi node-cleanup tomonidan yopildi.');
    cleanup.uninstall(); // Ushbu callbackni qayta chaqirishni oldini olish uchun izohdan olib tashlang (quyida qo'shimcha ma'lumot)
    return false;
});

  for await (const line of stream) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

Amaliy Misollar va Stsenariylar

1. Ma'lumotlar Bazasidan Ma'lumotlarni Oqim Shaklida Olish

Ma'lumotlar bazasidan ma'lumotlarni oqim shaklida olayotganda, oqim qayta ishlanib bo'lgach, ma'lumotlar bazasi ulanishini yopish juda muhimdir.

            const { Pool } = require('pg');

async function* streamDataFromDatabase(query) {
  const pool = new Pool({ /* ulanish ma'lumotlari */ });
  let client;
  try {
    client = await pool.connect();
    const result = await client.query(query);
    for (const row of result.rows) {
      yield row;
    }
  } finally {
    if (client) {
      client.release(); // Klientni pool'ga qaytarish
      console.log('Ma\'lumotlar bazasi ulanishi bo\'shatildi.');
    }
    await pool.end(); // Pool'ni yopish
    console.log('Ma\'lumotlar bazasi pooli yopildi.');
  }
}

(async () => {
  for await (const row of streamDataFromDatabase('SELECT * FROM users')) {
    console.log(row);
  }
})();

            

              
                Copy
              
            
          

2. Katta Hajmdagi CSV Fayllarni Qayta Ishlash

Katta hajmdagi CSV fayllarni qayta ishlayotganda, xotira sizib chiqishining oldini olish uchun har bir qatorni qayta ishlagandan so'ng fayl oqimini yopish muhimdir.

            const fs = require('fs');
const csv = require('csv-parser');

async function* processCsvFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    const parser = csv();
    fileStream.pipe(parser);

    for await (const row of parser) {
      yield row;
    }
  } finally {
    if (fileStream) {
      fileStream.close(); // Oqimni to'g'ri yopadi
      console.log('CSV fayl oqimi yopildi.');
    }
  }
}

(async () => {
  const filePath = 'data.csv'; // O'zingizning CSV fayl yo'lingiz bilan almashtiring
  fs.writeFileSync(filePath, 'header1,header2\nvalue1,value2\nvalue3,value4');

  for await (const row of processCsvFile(filePath)) {
    console.log(row);
  }
})();

            

              
                Copy
              
            
          

3. API'dan Ma'lumotlarni Oqim Shaklida Olish

API'dan ma'lumotlarni oqim shaklida olayotganda, oqim qayta ishlanib bo'lgach, tarmoq ulanishini yopish juda muhimdir.

            const https = require('https');

async function* streamDataFromApi(url) {
  let responseStream;
  try {
    const promise = new Promise((resolve, reject) => {
      https.get(url, (res) => {
        responseStream = res;
        res.on('data', (chunk) => {
          resolve(chunk.toString());
        });

        res.on('end', () => {
          resolve(null);
        });

        res.on('error', (error) => {
          reject(error);
        });

      }).on('error', (error) => {
        reject(error);
      });
    });

    while(true) {
      const chunk = await promise; // Promise'ni kuting, u chunk qaytaradi.
      if (!chunk) break;
      yield chunk;
    }
  } finally {
      if (responseStream && typeof responseStream.destroy === 'function') { // Xavfsizlik uchun destroy mavjudligini tekshiring.
          responseStream.destroy();
          console.log('API oqimi yo\'q qilindi.');
      }
  }
}

(async () => {
  // Oqimli ma'lumotlarni qaytaradigan ommaviy API'dan foydalaning (masalan, katta JSON fayl)
  const apiUrl = 'https://jsonplaceholder.typicode.com/todos/1';

  for await (const chunk of streamDataFromApi(apiUrl)) {
    console.log('Chunk:', chunk);
  }
})();

            

              
                Copy
              
            
          

Mustahkam Resurslarni Boshqarish uchun Eng Yaxshi Amaliyotlar

JavaScript asinxron generatorlarida mustahkam resurslarni boshqarishni ta'minlash uchun quyidagi eng yaxshi amaliyotlarga rioya qiling:

• Har doim try...finally bloklaridan foydalaning, bu xatolik yuz berishidan yoki generatorning normal yakunlanishidan qat'i nazar, tozalash kodining bajarilishini ta'minlaydi.
• Resurs hech qachon ishga tushirilmagan bo'lsa, xatoliklarning oldini olish uchun resurslarni yopishga urinishdan oldin ularning mavjudligini tekshiring.
• Generator'dan chiqishdan oldin resurslarning to'liq yopilishini kafolatlash uchun asinxron close() metodlarini kuting (await).
• Generatorning ishdan chiqishini oldini olish va resurslarning to'g'ri tozalanishini ta'minlash uchun xatoliklarni to'g'ri boshqaring.
• Resurs ajratish va tozalash mantig'ini jamlash uchun o'rovchi (wrapper) funksiyalardan foydalaning, bu kodning qayta ishlatilishini rag'batlantiradi va generator kodini soddalashtiradi.
• Asinxron operatsiyalarni bekor qilishning standart usulini ta'minlash va oqimni qayta ishlashni toza bekor qilishni ta'minlash uchun AbortController dan foydalaning.
• Andoza kodini kamaytirish va ilovalaringiz ishonchliligini oshirish uchun oqimlarni boshqarish uchun kutubxonalardan foydalaning.
• Qaysi resurslarni tozalash kerakligini va buni qanday qilishni ko'rsatish uchun kodingizni aniq hujjatlashtiring.
• Turli stsenariylarda, shu jumladan xatolik sharoitlarida va bekor qilishlarda resurslarning to'g'ri tozalanishini ta'minlash uchun kodingizni sinchkovlik bilan sinab ko'ring.

Xulosa

Resurslarni to'g'ri boshqarish asinxron generatorlardan foydalanadigan mustahkam va ishonchli JavaScript ilovalarini yaratish uchun juda muhimdir. Ushbu qo'llanmada keltirilgan usullar va eng yaxshi amaliyotlarga rioya qilish orqali siz xotira sizib chiqishining oldini olishingiz, oqimni samarali tozalashni ta'minlashingiz va xatoliklarga hamda kutilmagan hodisalarga chidamli ilovalar yaratishingiz mumkin. Ushbu amaliyotlarni qo'llash orqali dasturchilar o'zlarining JavaScript ilovalarining, ayniqsa oqimli ma'lumotlar yoki asinxron operatsiyalar bilan ishlaydiganlarning barqarorligi va masshtablanuvchanligini sezilarli darajada yaxshilashlari mumkin. Potentsial muammolarni rivojlanish jarayonining boshida aniqlash uchun resurslarni tozalashni har doim sinchkovlik bilan sinab ko'rishni unutmang.